---
title: Collection(集合)
sidebar_position: 1
---

# Collection

### Empty(集合判空)

:::note
判断集合是否为空, 当集合为 `null` 或者其中的元素为空时返回 `true`
:::

```csharp
using Collapsenav.Net.Tool;
string[] nullArray = null;
List<string> emptyList = new();
int[] notEmptyArray = new[] { 1, 2, 3, 4 };
nullArray.IsEmpty(); //true
emptyList.NotEmpty(); // false
emptyList.IsEmpty(); // true
notEmptyArray.NotEmpty(); // true
notEmptyArray.IsEmpty(); // false
```

### AllContain(A是否包含B)

:::note
用于判断 A集合 是完全包含 B集合, 当 B 被完全包含在 A 中时, 返回 `true`
:::

```csharp
using Collapsenav.Net.Tool;
string[] strList = { "1", "2", "3", "4", "5", "6" };
strList.AllContain(new[] { "2", "6" }); // True
strList.AllContain("2", "8", "10", "11", "20"); // False
```

:::tip
可传入委托进行自定义判断, 适用于自定义类型或者引用类型
:::

```csharp
strList.AllContain((x, y) => x == y, "2", "8", "10", "11", "20"); // False
strList.AllContain(new[] { "2", "6" }, (x, y) => x == y); // True
strList.AllContain(new[] { "2", "6" }, x => x); // True
```

### HasContain(A是否包含B的元素)

:::note
用于判断 A集合 是否**部分**包含了 B 集合中的元素, 只要包含一个元素则为 `True`
:::

```csharp
string[] strList = { "1", "2", "3", "4", "5", "6" };
strList.HasContain(new[] { "2", "6" }); // True
strList.HasContain(new[] { "2", "8" }); // True
strList.HasContain("7", "8"); // False
```

:::tip
可传入委托进行自定义判断, 适用于自定义类型或者引用类型
:::

```csharp
strList.HasContain((x, y) => x == y, new[] { "2", "6" }); // True
strList.HasContain(new[] { "2", "8" }, (x, y) => x == y); // True
strList.HasContain((x, y) => x == y, "7", "8"); // False
```

### Merge(集合合并)

:::note
可用于将二维数组或者二维集合合并为一维
:::

```csharp
IEnumerable<int[]> nums = new List<int[]>()
{
    new[] {1,2,3},
    new[] {4,5,6},
    new[] {7,8,9},
    new[] {10},
};
var numMergeList = nums.Merge();
numMergeList = nums.Take(2).Merge(nums.TakeLast(2));
numMergeList = nums.Take(2).Merge(new[] { 7, 8, 9, 10 });

numMergeList = nums.Merge((x, y) => x == y, item => item.GetHashCode());
// { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
```

:::tip
`Merge` 中的参数维数需要小于等于源集合

可通过传入委托在合并的同时去重
:::

### SpliteCollection(分割集合)

:::note
将集合按照划分为指定的长度
:::

```csharp
var nums = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var numSplit = nums.SpliteCollection(2);
/*
    {1,2}
    {3,4}
    {5,6}
    {7,8}
    {9,10}
*/
numSplit = nums.SpliteCollection(3);
/*
    {1,2,3}
    {4,5,6}
    {7,8,9}
    {10}
*/
```

### WhereIf

```csharp
int[] intList = { 1, 1, 2, 2, 3, 3, 4 };
intList = intList.WhereIf(true, item => item > 1)
.WhereIf(false, item => item < 3)
.WhereIf("", item => item != 2)
.ToArray();
// {2,2,3,3,4}
```

### Unique(去重)

:::note
集合去重
:::

```csharp
int[] intList = { 1, 1, 2, 2, 3, 3, 4 };
intList.Unique();
// 1,2,3,4
```

:::tip
针对自定义类型可以通过传入委托进行去重
:::

```csharp
intList.Unique(item => item);
intList.Unique((x, y) => x == y);
```

### SequenceEqual(集合是否相等)

:::note
判断两个集合是否相等, 针对自定义类型可以通过传入委托进行去重
:::

```csharp
IEnumerable<UserInfo> userInfos = new List<UserInfo> {
    new(){UserName="23331",Age=231 },
    new(){UserName="23332",Age=232 },
};
IEnumerable<UserInfo> userInfosCopy = new List<UserInfo> {
    new(){UserName="23331",Age=231 },
    new(){UserName="23332",Age=232 },
};
IEnumerable<UserInfo> userInfosNotCopy = new List<UserInfo> {
    new(){UserName="23331",Age=23 },
    new(){UserName="23332",Age=23 },
};
userInfos.SequenceEqual(userInfosCopy); // false
userInfos.SequenceEqual(userInfosCopy, (x, y) => x.UserName == y.UserName); // true
userInfos.SequenceEqual(userInfosCopy, item => item.Age.GetHashCode()); // true

userInfos.SequenceEqual(userInfosNotCopy); // false
userInfos.SequenceEqual(userInfosNotCopy, (x, y) => x.UserName == y.UserName); // true
userInfos.SequenceEqual(userInfosNotCopy, item => item.Age.GetHashCode()); // false
```

### Shuffle

:::note
打乱集合内元素的顺序
:::

```csharp
var nums = new[] { 1, 2, 3, 4, 5 };
nums = nums.Shuffle();
// 可能变成了 2,4,5,1,3 或者其他顺序
```

### ForEach

:::note
遍历集合
:::

```csharp
var sum = 0;
int[] nums = new[] { 1, 2, 3 };
nums.ForEach(item => sum += item);
// sum == 6
```

### AddRange

:::note
向集合中批量添加元素
:::

```csharp
IEnumerable<int> nums = new[] { 1, 2, 3 };
// IEnumerable 会产生一个新的集合
var enums = nums.AddRange(4, 5);

ICollection<int> nums = new List<int> { 1, 2, 3 };
// ICollection 将直接在原集合上进行修改
nums.AddRange(4, 5, 6);
```

:::tip
如果继承了 `ICollection` 则会使用第二种 `AddRange`, 不然就是第一种

同时提供了在 `AddRange` 时去重的重载, 只会对传入的集合去重, 如果需要对原集合进行去重, 最好使用上面的 [`Unique`](#unique去重)
:::

```csharp
var nums = new[] { 1, 2, 3 };
var enums = nums.AddRange((x, y) => x == y, 3, 4, 5);
// enums { 1, 2, 3, 4, 5 }
```

### SelectWithIndex

:::info
返回带index的集合, 主要是为了方便写 `foreach`
:::

```csharp
int[] nums = new[] { 1, 2, 3 };
foreach (var (item, index) in nums.SelectWithIndex());
```

:::tip
可以通过委托决定返回的 `item` 和 `index`
:::

```csharp
foreach (var (item, index) in nums.SelectWithIndex(num => num * num));
foreach (var (item, index) in nums.SelectWithIndex(num => num.ToString(), num => num));
```

### In

:::note
判断 A元素 是否在 B集合中
:::

```csharp
int[] nums = new[] { 1, 2, 3 };
1.In(nums); // True
4.In(nums); // False
```

:::tip
与其他集合扩展一样, 支持使用委托进行判断
:::

```csharp
int[] nums = new[] { 1, 2, 3 };
1.In(nums, (x,y) => x == y); // True
4.In(nums, (x,y) => x == y); // False
```

### GetItemIn/Intersect(交集)

```csharp
var list1 = new[] { 1, 2, 3, 4 };
var list2 = new[] { 3, 4, 5, 6 };
list1.GetItemIn(list2); // {3, 4}
list1.Intersect(list2, (a, b) => a == b); // {3, 4}
```

### GetItemNotIn/Except(差集)

```csharp
var list1 = new[] { 1, 2, 3, 4 };
var list2 = new[] { 3, 4, 5, 6 };
list1.GetItemNotIn(list2); // {1, 2}
list1.Except(list2, (a, b) => a == b); // {1, 2}
```